home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus Leser 15 / Amiga Plus Leser CD 15.iso / Tools / Development / PluginSRC_EvenMore / Eml2Text.e < prev    next >
Encoding:
Text File  |  2002-03-13  |  10.6 KB  |  492 lines
  1. /*
  2.    WordWorth2Text
  3.    EvenMore FileIO plugin
  4.    Author: Chris Perver
  5.    Copyright (c) 2001
  6. */
  7.  
  8.  
  9. OPT REG=5
  10.  
  11. LIBRARY 'eml2text.plugin',1,1,'Eml2Text 1.09' IS em_main, em_end, em_info, em_pluginid, em_begin, em_format
  12.  
  13. MODULE 'tools/ctype', '*epo', '*converthtml'
  14.  
  15. DEF mem2, count2 = 0
  16.  
  17.  
  18. PROC em_isdatatype(bf:PTR TO CHAR, bl)
  19.   DEF working = TRUE, i = 0, c = 0,rc= FALSE
  20.   DEF str[20]:STRING
  21.  
  22.   WHILE working
  23.     WHILE working ->(bf[i] <> "\n")
  24.       EXIT (bf[i] = "\n") OR (bf[i] = "\b")
  25.       INC i
  26.       IF (i>=bl) THEN working := FALSE
  27.  
  28.     ENDWHILE
  29.     INC i
  30.  
  31.     SELECT 256 OF bf[c]
  32.       CASE "M", "m"
  33.         StrCopy(str, bf + c, 15)
  34.         UpperStr(str)
  35.         IF InStr(str, 'MIME-VERSION: ') = 0
  36.           working := FALSE
  37.           rc := TRUE
  38.         ELSE
  39.           c := i
  40.         ENDIF
  41.       DEFAULT
  42.         c := i
  43.     ENDSELECT
  44.   ENDWHILE
  45. ENDPROC rc
  46.  
  47.  
  48. PROC em_parsedata(epo:PTR TO em_pluginobj)
  49.   DEF count = 0
  50.   DEF notdone = TRUE
  51.   DEF i, eol, j, eml[256]:STRING, bound[256]:STRING
  52.   DEF format = 0
  53.   DEF isprint = FALSE, isbound = FALSE
  54.   DEF htmlstart = 0, htmlend, notbegun = TRUE
  55.   DEF hex:PTR TO CHAR, eolchar:PTR TO CHAR, memadr:PTR TO CHAR, lenadr
  56.   DEF crlf = FALSE, loop, printable = FALSE
  57.  
  58.   StrCopy(bound, '')
  59.  
  60.   memadr := epo.buffer
  61.   lenadr := epo.length
  62.  
  63.   mem2 := epo.nbuffer
  64.  
  65.   i := count
  66.  
  67.   WHILE ((memadr[i] <> "\n") AND (memadr[i] <> "\b")) DO INC i
  68.  
  69.   IF memadr[i] = "\n"
  70. ->    IF memadr[i-1] = "\b"
  71. ->      eolchar := "\n"
  72. ->    ELSE
  73.       eolchar := "\n"
  74. ->    ENDIF
  75.   ELSE
  76.     IF memadr[i+1] = "\n"
  77.       crlf := TRUE
  78.       eolchar := "\n"
  79.     ELSE
  80.       eolchar := "\b"
  81.     ENDIF
  82.   ENDIF
  83.  
  84.  
  85.   WHILE notdone AND (count < lenadr)
  86.     eol := count
  87.     WHILE memadr[eol] <> eolchar DO INC eol
  88.     INC eol
  89.  
  90.     UpperStr(StrCopy(eml, memadr + count, eol - count))
  91.  
  92.     IF InStr(eml, 'FROM:') = 0
  93.       mem2[count2++] := "\e"
  94.       mem2[count2++] := "["
  95.       mem2[count2++] := "4"
  96.       mem2[count2++] := "3"
  97.       mem2[count2++] := "m"
  98.  
  99.       WHILE (count < eol) DO mem2[count2++] := memadr[count++]
  100.  
  101.       count := eol
  102.  
  103.     ELSEIF InStr(eml, 'TO:') = 0
  104.  
  105.       mem2[count2++] := "\e"
  106.       mem2[count2++] := "["
  107.       mem2[count2++] := "4"
  108.       mem2[count2++] := "3"
  109.       mem2[count2++] := "m"
  110.  
  111.       WHILE (count < eol) DO mem2[count2++] := memadr[count++]
  112.  
  113.       count := eol
  114.  
  115.     ELSEIF InStr(eml, 'DATE:') = 0
  116.  
  117.       mem2[count2++] := "\e"
  118.       mem2[count2++] := "["
  119.       mem2[count2++] := "4"
  120.       mem2[count2++] := "3"
  121.       mem2[count2++] := "m"
  122.  
  123.       WHILE (count < eol) DO mem2[count2++] := memadr[count++]
  124.  
  125.       count := eol
  126.  
  127.     ELSEIF InStr(eml, 'SUBJECT:') = 0
  128.       mem2[count2++] := "\e"
  129.       mem2[count2++] := "["
  130.       mem2[count2++] := "4"
  131.       mem2[count2++] := "3"
  132.       mem2[count2++] := "m"
  133.  
  134.       WHILE (count < eol) DO mem2[count2++] := memadr[count++]
  135.  
  136.       count := eol
  137.  
  138.     ELSEIF InStr(eml, 'CONTENT-TRANSFER-ENCODING: ') = 0
  139.       IF isprint
  140.         IF InStr(eml, 'QUOTED-PRINTABLE') >= 0 THEN printable := TRUE
  141.       ENDIF
  142.  
  143.       count := eol
  144.  
  145.  
  146.     ELSEIF InStr(eml, 'CONTENT-TYPE:') = 0
  147.  
  148.       IF InStr(eml, 'TEXT/HTML') >= 0
  149.  
  150.         IF format = 0
  151.           format := 2
  152.         ENDIF
  153.  
  154.         j := count
  155.         WHILE memadr[j] <> ";" DO INC j
  156.         INC j
  157.  
  158.  
  159.         WHILE memadr[eol] <> eolchar DO INC eol
  160.         INC eol
  161.  
  162.         IF format = 2
  163.           -> CHECK IF WE ARE TO REALIGN LF's
  164.           StrCopy(eml, memadr + eol, 50)
  165.           UpperStr(eml)
  166.  
  167.           IF InStr(eml, 'QUOTED-PRINTABLE') >= 0 THEN printable := TRUE
  168.         ENDIF
  169.  
  170.   ->      count := eol
  171.  
  172.         IF format = 2
  173.           isprint := TRUE
  174.           mem2[count2++] := "\n"
  175.  
  176.           -> SKIP UNTIL WE HIT 2 LF's WHICH IS WHERE OUR MESSAGE STARTS
  177.           loop := TRUE
  178.           WHILE loop
  179.             WHILE memadr[eol] <> eolchar DO INC eol
  180.             IF crlf
  181.               IF memadr[eol+2] = eolchar
  182.                 eol := eol + 2
  183.                 loop := FALSE
  184.               ENDIF
  185.             ELSE
  186.               IF memadr[eol+1] = eolchar
  187.                 INC eol
  188.                 loop := FALSE
  189.               ENDIF
  190.             ENDIF
  191.             INC eol
  192.           ENDWHILE
  193.        ->   INC eol
  194.         ELSE
  195.           isprint := FALSE
  196.  
  197.           -> Skip until next boundary!
  198.  
  199.           WHILE TRUE
  200.             -> SKIP LINE UNTIL WE GET FIRST BOUNDS
  201.             j := eol
  202.             WHILE memadr[eol] <> eolchar DO INC eol
  203.             INC eol
  204.  
  205.             StrCopy(eml, memadr + j, eol - j)
  206.             UpperStr(eml)
  207.             EXIT (InStr(eml, bound) >= 0)
  208.           ENDWHILE
  209.         ->  count := eol
  210.         ENDIF
  211.  
  212.         count := eol
  213.  
  214.  
  215.  
  216.  
  217.  
  218.  
  219.       ELSEIF InStr(eml, 'MULTIPART') >= 0
  220.         IF InStr(eml, '/ALTERNATIVE') >= 0 THEN format := 2
  221.  
  222.  
  223.         j := count
  224.         WHILE memadr[j] <> ";" DO INC j
  225.         INC j
  226.  
  227.  
  228.         StrCopy(eml, memadr + j, 50)
  229.         UpperStr(eml)
  230.  
  231.         IF InStr(eml, 'BOUNDARY=') >= 0
  232.  
  233.           -> GET START OF STRING
  234.           WHILE memadr[j] <> $22 DO INC j
  235.           INC j
  236.  
  237.           -> GET END OF STRING
  238.           eol := j
  239.           WHILE memadr[eol] <> $22 DO INC eol
  240.  
  241.           StrCopy(bound, memadr + j , eol-j -1)
  242.           UpperStr(bound)
  243.  
  244.           isbound := TRUE
  245.           WHILE memadr[eol] <> eolchar DO INC eol
  246.           INC eol
  247.         ELSEIF InStr(eml, 'CHARSET=') >= 0
  248.           WHILE memadr[eol] <> eolchar DO INC eol
  249.           INC eol
  250.         ENDIF
  251.         count := eol
  252.  
  253.  
  254.         -> Skip until next boundary!
  255.  
  256.         WHILE TRUE
  257.           -> SKIP LINE UNTIL WE GET FIRST BOUNDS
  258.           j := eol
  259.           WHILE memadr[eol] <> eolchar DO INC eol
  260.           INC eol
  261.  
  262.           StrCopy(eml, memadr + j, eol - j)
  263.           UpperStr(eml)
  264.           EXIT (InStr(eml, bound) >= 0)
  265.         ENDWHILE
  266.         count := eol
  267.  
  268.  
  269.  
  270.  
  271.  
  272.  
  273.  
  274.  
  275.  
  276.  
  277.  
  278.  
  279.       ELSEIF InStr(eml, 'TEXT/PLAIN') >= 0
  280.         IF format = 0 THEN format := 1
  281.  
  282.         j := count
  283.         WHILE memadr[j] <> ";" DO INC j
  284.         INC j
  285.  
  286.         WHILE memadr[eol] <> eolchar DO INC eol
  287.         INC eol
  288.  
  289.         IF format = 1
  290.           -> CHECK IF WE ARE TO REALIGN LF's
  291.           StrCopy(eml, memadr + eol, 50)
  292.           UpperStr(eml)
  293.           IF InStr(eml, 'QUOTED-PRINTABLE') >= 0 THEN printable := TRUE
  294.         ENDIF
  295.  
  296.         IF format = 1
  297.           isprint := TRUE
  298.           mem2[count2++] := "\n"
  299.  
  300.  
  301.           -> SKIP UNTIL WE HIT 2 LF's WHICH IS WHERE OUR MESSAGE STARTS
  302.           loop := TRUE
  303.           WHILE loop
  304.             WHILE memadr[eol] <> eolchar DO INC eol
  305.             IF crlf
  306.               IF memadr[eol+2] = eolchar
  307.                 eol := eol + 2
  308.                 loop := FALSE
  309.               ENDIF
  310.             ELSE
  311.               IF memadr[eol+1] = eolchar
  312.                 INC eol
  313.                 loop := FALSE
  314.               ENDIF
  315.             ENDIF
  316.             INC eol
  317.           ENDWHILE
  318.  
  319.  
  320.         ELSE
  321.  
  322.           -> Skip until next boundary!
  323.  
  324.           WHILE TRUE
  325.  
  326.             -> SKIP LINE UNTIL WE GET FIRST BOUNDS
  327.             j := eol
  328.             WHILE memadr[eol] <> eolchar DO INC eol
  329.             INC eol
  330.  
  331.             StrCopy(eml, memadr + j, eol - j)
  332.             UpperStr(eml)
  333.             EXIT (InStr(eml, bound) >= 0)
  334.           ENDWHILE
  335.  
  336.           isprint := FALSE
  337.         ENDIF
  338.         count := eol
  339.  
  340.       ELSE
  341.         count := eol
  342.       ENDIF
  343.  
  344.  
  345.  
  346.     ELSE
  347.  
  348.  
  349.      IF isprint
  350.  
  351.         IF isbound
  352.           IF InStr(eml, bound) >= 0
  353.             count := eol
  354.             isprint := FALSE
  355.           ENDIF
  356.         ENDIF
  357.  
  358.         WHILE count < eol
  359.  
  360.           IF notbegun
  361.             htmlstart := count2
  362.             notbegun := FALSE
  363.           ENDIF
  364.  
  365.  
  366.           SELECT 256 OF memadr[count]
  367.             CASE "="
  368.               SELECT 256 OF memadr[count+1]
  369.  
  370.                 CASE " "
  371.                   WHILE memadr[count] <> eolchar DO INC count
  372.                   INC count
  373.                 CASE "\b"
  374.                   WHILE memadr[count] <> eolchar DO INC count
  375.                   INC count
  376.                 CASE "\n"
  377.                   WHILE memadr[count] <> eolchar DO INC count
  378.                   INC count
  379.  
  380.  
  381.                 DEFAULT
  382.  
  383.                   IF (printable = FALSE) ->(memadr[count+1] = eolchar) OR (memadr[count + 2] = eolchar)
  384.                     mem2[count2++] := memadr[count++]
  385.                   ELSE
  386.                   SELECT 256 OF memadr[count + 1]
  387.                     CASE "0"; hex := $00
  388.                     CASE "1"; hex := $10
  389.                     CASE "2"; hex := $20
  390.                     CASE "3"; hex := $30
  391.                     CASE "4"; hex := $40
  392.                     CASE "5"; hex := $50
  393.                     CASE "6"; hex := $60
  394.                     CASE "7"; hex := $70
  395.                     CASE "8"; hex := $80
  396.                     CASE "9"; hex := $90
  397.                     CASE "A"; hex := $A0
  398.                     CASE "B"; hex := $B0
  399.                     CASE "C"; hex := $C0
  400.                     CASE "D"; hex := $D0
  401.                     CASE "E"; hex := $E0
  402.                     CASE "F"; hex := $F0
  403.                   ENDSELECT
  404.                   SELECT 256 OF memadr[count + 2]
  405.                     CASE "0"; hex := hex + $00
  406.                     CASE "1"; hex := hex + $01
  407.                     CASE "2"; hex := hex + $02
  408.                     CASE "3"; hex := hex + $03
  409.                     CASE "4"; hex := hex + $04
  410.                     CASE "5"; hex := hex + $05
  411.                     CASE "6"; hex := hex + $06
  412.                     CASE "7"; hex := hex + $07
  413.                     CASE "8"; hex := hex + $08
  414.                     CASE "9"; hex := hex + $09
  415.                     CASE "A"; hex := hex + $0A
  416.                     CASE "B"; hex := hex + $0B
  417.                     CASE "C"; hex := hex + $0C
  418.                     CASE "D"; hex := hex + $0D
  419.                     CASE "E"; hex := hex + $0E
  420.                     CASE "F"; hex := hex + $0F
  421.                   ENDSELECT
  422.  
  423.                   mem2[count2++] := hex
  424.                   count := count + 3
  425.  
  426.                   ENDIF
  427.               ENDSELECT
  428.         ->      ENDIF
  429.  
  430.             DEFAULT
  431.               mem2[count2++] := memadr[count++]
  432.           ENDSELECT
  433.  
  434.         ENDWHILE
  435.  
  436.         count := eol
  437.       ELSE
  438.         count := eol
  439.  
  440.       ENDIF
  441.  
  442.  
  443.     ENDIF
  444.  
  445.    -> INC count
  446.   ENDWHILE
  447.  
  448.   mem2[count2] := "\n"
  449.  
  450.   htmlend := count2
  451.  
  452.   IF format = 2
  453.     mem2, count2 := convhtml(mem2, htmlstart, htmlend)
  454.   ENDIF
  455.  
  456.  -> IF memadr
  457.  ->   Dispose(memadr); memadr := NIL
  458.  -> ENDIF
  459. ENDPROC mem2, count2
  460. -><
  461.  
  462.  
  463. -> *** STANDARD PROCS FOR PLUGINS
  464.  
  465.  
  466. PROC em_main(epo:PTR TO em_pluginobj)
  467.   DEF len2
  468.     mem2, len2 := em_parsedata(epo)
  469.     epo.nlength := len2
  470.     RETURN TRUE
  471. ENDPROC
  472.  
  473. PROC em_begin(epo:PTR TO em_pluginobj)
  474.   IF em_isdatatype(epo.buffer, epo.length)
  475.     RETURN "MEM", (epo.length * 2)
  476.   ELSE
  477.     RETURN FALSE
  478.   ENDIF
  479. ENDPROC
  480.  
  481. PROC em_end()      IS EMPTY
  482.  
  483. PROC em_info()     IS 'Eml2Text 1.09'
  484.  
  485. PROC em_format()   IS 'Mime'
  486.  
  487. PROC em_pluginid() IS "FILE"
  488.  
  489. PROC main()        IS EMPTY
  490.  
  491.  
  492.